Parte I : Aprendizado Supervisionado

Modelos baseados em árvores

De funções suaves para regras

Até aqui, aproximamos \(g(\mathbf{x})\) usando funções suaves:

splines
regressão local
kernels

Árvores seguem outra lógica:

\[ \small \boxed{ \text{dividir o espaço de } \mathbf{x} \longrightarrow \text{formar regiões homogêneas} \longrightarrow \text{predizer dentro de cada região} } \]

De funções suaves para regras

A estrutura da árvore é praticamente a mesma em regressão e classificação.

O que muda é:

o que significa “região homogênea”, o que guardamos nas folhas e como combinamos as árvores.

Nós, ramos, folhas e regiões

Cada caminho da raiz até uma folha define uma região \(\mathcal{R}_m\). Quatro folhas correspondem às regiões \(\mathcal{R}_1,\ldots,\mathcal{R}_4\).

Nós, ramos, folhas e regiões

Da raiz até uma folha, fazemos uma sequência de perguntas do tipo

\[ X_j \leq s? \]

Cada resposta escolhe um ramo. Ao final,

\[ \boxed{\text{folha }m \Longleftrightarrow \text{região }\mathcal{R}_m} \]

A árvore é simultaneamente um conjunto de regras, uma partição do espaço preditor e um modelo que associa uma previsão a cada região.

Nós, ramos, folhas e regiões

Uma árvore com \(M\) folhas particiona o espaço em

\[ \mathcal{R}_1,\mathcal{R}_2,\ldots,\mathcal{R}_M. \]

Para uma nova observação \(\mathbf{x}\):

começamos no nó raiz;
seguimos as regras de divisão;
chegamos a uma única folha;
usamos a previsão associada àquela região.

\[ \boxed{ \mathbf{x}\in\mathcal{R}_m \quad\Rightarrow\quad \text{predição da folha }m } \]

Nós, ramos, folhas e regiões

	Regressão	Classificação
Resposta	quantitativa	categórica
Resumo da folha	média \(\bar y_m\)	proporções \(\hat p_{mk}\)
Predição	\(\hat y=\bar y_m\)	classe de maior probabilidade
Região boa	valores de \(y\) parecidos	predominância de uma classe

Nós, ramos, folhas e regiões

Para regressão:

\[ \hat g(\mathbf{x}) = \sum_{m=1}^{M}\bar y_m\,I(\mathbf{x}\in\mathcal{R}_m) \]

Para classificação:

\[ \hat p_k(\mathbf{x}) = \hat p_{mk}, \qquad \mathbf{x}\in\mathcal{R}_m \]

A pergunta feita em cada nó

Para cada variável \(X_j\) e ponto de corte \(s\), testamos uma regra:

\[ X_j\leq s \qquad\text{versus}\qquad X_j>s. \]

Ela cria duas regiões filhas.

A árvore procura a divisão que produz filhos mais homogêneos que o pai.

\[ \boxed{ \text{melhor split} = \text{maior ganho de homogeneidade} } \]

O significado de homogeneidade depende do problema.

Regressão: reduzir o erro quadrático

Em uma região \(\mathcal{R}_m\), a melhor constante sob perda quadrática é

\[ \bar y_m = \frac{1}{n_m} \sum_{i:\mathbf{x}_i\in\mathcal{R}_m}y_i \]

A impureza do nó pode ser medida por

\[ RSS_m = \sum_{i:\mathbf{x}_i\in\mathcal{R}_m} (y_i-\bar y_m)^2 \]

Regressão: reduzir o erro quadrático

Uma boa divisão produz:

\[ \boxed{ RSS_{\text{esq}}+RSS_{\text{dir}} < RSS_{\text{pai}} } \]

Quanto maior a redução, melhor o split.

Classificação: reduzir a mistura de classes

Se \(\hat p_{mk}\) é a proporção da classe \(k\) no nó \(m\), uma medida comum é o índice de Gini:

\[ G_m = 1-\sum_{k=1}^{K}\hat p_{mk}^{\,2} \]

\(G_m=0\): nó puro
\(G_m\) maior: classes mais misturadas

Classificação: reduzir a mistura de classes

A árvore escolhe o split que reduz a impureza ponderada:

\[ \boxed{ G_{\text{pai}} - \left( \frac{n_E}{n}G_E+ \frac{n_D}{n}G_D \right) } \]

Uma alternativa ao índice de Gini é a entropia:

\[ \boxed{ H_m = -\sum_{k=1}^{K} \hat p_{mk}\log_2(\hat p_{mk}) } \]

onde \(\hat p_{mk}\) é a proporção de observações da classe \(k\) no nó \(m\).

Classificação: reduzir a mistura de classes

Entropia baixa \(\rightarrow\) nó mais puro
Entropia alta \(\rightarrow\) maior mistura entre as classes

Tanto Gini quanto entropia procuram a mesma coisa: divisões que produzam nós filhos mais puros que o nó pai.

Mesma árvore, critérios diferentes

Regressão

Pergunta

A divisão reduz a dispersão dos valores de \(Y\)?

Critério típico:

\[ RSS \]

Folha:

\[ \bar y_m \]

Classificação

Pergunta

A divisão separa melhor as classes?

Critérios típicos:

\[ \text{Gini ou Entropia} \]

Folha:

\[ (\hat p_{m1},\ldots,\hat p_{mK}) \]

Exemplo: uma árvore de regressão

Exemplo: uma árvore de classificação

Árvore profunda: baixo viés, alta variância

Uma árvore pode continuar dividindo os dados até criar folhas muito pequenas.

Isso reduz o erro de treinamento, mas pode produzir regras instáveis.

\[ \boxed{ \text{árvore muito profunda} \Rightarrow \text{maior flexibilidade} \Rightarrow \text{maior risco de overfitting} } \]

Pequenas mudanças na amostra podem gerar uma árvore bastante diferente.

Poda (pruning)

Para regressão, uma forma de pensar na poda é:

\[ \boxed{ \text{erro da árvore} + \alpha\times\text{complexidade} } \]

ou, mais especificamente,

\[ \sum_{m=1}^{|T|} \sum_{i:\mathbf{x}_i\in\mathcal{R}_m} (y_i-\bar y_m)^2 + \alpha|T| \]

\(\alpha\) pequeno \(\rightarrow\) árvore maior
\(\alpha\) grande \(\rightarrow\) árvore menor
\(T:\) árvore
\(|T|:\) número de folhas (nós terminais) de \(T\)

Poda (pruning)

Na classificação, a mesma lógica é usada com uma medida apropriada de erro/impureza.

A poda regulariza uma árvore. Bagging, Random Forest e Boosting seguem outra estratégia: combinar muitas árvores.

O problema da árvore individual

Árvores são:

interpretáveis
capazes de capturar não linearidade
capazes de capturar interações

Mas são também:

instáveis
sensíveis à amostra
de alta variância

Por que combinar árvores?

Imagine que treinamos duas árvores de regressão e, para uma mesma entrada \(\mathbf{x}\), elas produzam, \(g_1(\mathbf{x})\) e \(g_2(\mathbf{x})\). Podemos combinar suas previsões pela média:

\[ \boxed{ g(\mathbf{x}) = \frac{g_1(\mathbf{x})+g_2(\mathbf{x})}{2} } \]

Se ambas têm o mesmo valor esperado,

\[ \mathbb{E}[g_1(\mathbf{x})] = \mathbb{E}[g_2(\mathbf{x})] = \mu_g(\mathbf{x}), \]

então

\[ \mathbb{E}[g(\mathbf{x})] = \frac{ \mathbb{E}[g_1(\mathbf{x})] + \mathbb{E}[g_2(\mathbf{x})] }{2} = \mu_g(\mathbf{x}) \]

Por que combinar árvores?

Portanto,

\[ \boxed{ \operatorname{Bias}[g(\mathbf{x})] = \mu_g(\mathbf{x})-f(\mathbf{x}) } \]

A média não corrige um viés comum às árvores.

Se \(g_1\) e \(g_2\) têm o mesmo viés, a combinação mantém esse viés, mas pode reduzir a variância.

A variância da previsão combinada é

\[ \operatorname{Var}\!\left[g(\mathbf{x})\right] = \frac{1}{4} \left[ \operatorname{Var}(g_1) + \operatorname{Var}(g_2) + 2\operatorname{Cov}(g_1,g_2) \right] \]

Por que combinar árvores?

Se as árvores têm a mesma variância \(\sigma_g^2\) e correlação \(\rho\),

\[ \boxed{ \operatorname{Var}\!\left[g(\mathbf{x})\right] = \frac{\sigma_g^2}{2}(1+\rho) } \]

Ideia central: fazer a média reduz a variância, mas o ganho é maior quando as árvores são menos correlacionadas.

\[ \rho \downarrow \quad\Longrightarrow\quad \operatorname{Var}[g(\mathbf{x})]\downarrow \]

Por que combinar árvores?

Assim, combinar modelos:

mantém o viés
reduz a variância

Três maneiras de combinar árvores

Os métodos diferem na forma de construir e combinar as árvores:

\[ \boxed{\text{Bagging: construir em paralelo} \;\longrightarrow\; \text{agregar}} \]

\[ \boxed{\text{Random Forest: construir em paralelo + descorrelacionar} \;\longrightarrow\; \text{agregar}} \]

\[ \boxed{\text{Boosting: construir sequencialmente} \;\longrightarrow\; \text{acumular}} \]

Qual é a ideia de cada estratégia?

Bagging: reduzir a variância pela agregação de árvores

Random Forest: reduzir a correlação entre as árvores, potencializando a redução da variância

Boosting: melhorar progressivamente o modelo, adicionando novas árvores de forma sequencial

Bagging (Bootstrap Aggregating)

Média de vários modelos instáveis → modelo mais estável

Bagging = Bootstrap + Aggregating

Para \(b=1,\ldots,B\):

sorteie uma amostra bootstrap;
ajuste uma árvore \(T_b\);
repita muitas vezes;
combine as previsões.

\[ \boxed{ \text{Bagging} = \text{Bootstrap} + \text{Agregação} } \]

As árvores são ajustadas em paralelo: uma não depende da anterior.

Como agregamos?

Regressão

Cada árvore fornece um número:

\[ \hat y_b(\mathbf{x}) \]

Agregamos pela média:

\[ \boxed{ \hat y_{\text{bag}}(\mathbf{x}) = \frac1B\sum_{b=1}^{B}\hat y_b(\mathbf{x}) } \]

Classificação

Cada árvore fornece classe ou probabilidades.

Podemos usar:

\[ \boxed{\text{voto majoritário}} \]

ou, preferencialmente, promediar probabilidades:

\[ \boxed{ \hat p_k(\mathbf{x}) = \frac1B\sum_{b=1}^{B}\hat p_{bk}(\mathbf{x}) } \]

Bagging em regressão: veja a estabilização

As árvores individuais variam bastante. A média acumulada se torna progressivamente mais estável.

Por que a média ajuda?

Se cada árvore tem variância aproximadamente \(\sigma^2\) e correlação média \(\rho\), então

\[ \boxed{ \operatorname{Var}(\bar T) = \rho\sigma^2+ \frac{1-\rho}{B}\sigma^2 } \]

Duas mensagens:

aumentar \(B\) reduz a segunda parcela;
a parcela \(\rho\sigma^2\) permanece.

Logo:

\[ \boxed{ \text{não basta ter muitas árvores; é útil que elas sejam diferentes} } \]

Bagging em classificação

O mecanismo é o mesmo:

\[ \text{bootstrap} \rightarrow \text{árvore de classificação} \rightarrow \text{probabilidade/voto} \rightarrow \text{agregação} \]

O que muda em relação à regressão?

Etapa	Regressão	Classificação
split	RSS/variância	Gini/entropia
folha	média	proporções/classes
agregação	média de \(\hat y\)	média de probabilidades/voto

Random Forest

Construir muitas árvores diferentes e combinar suas previsões

O limite do Bagging

Mesmo com amostras bootstrap diferentes, árvores podem ficar muito parecidas.

Por quê?

Se uma variável é muito forte, ela tende a ser escolhida repetidamente perto da raiz.

Resultado:

\[ \text{árvores semelhantes} \Rightarrow \rho \text{ alto} \Rightarrow \text{menor redução de variância}. \]

Random Forest: descorrelacionar as árvores

O Random Forest adiciona uma segunda fonte de aleatoriedade.

Para cada árvore:

sorteamos uma amostra bootstrap;
em cada nó, sorteamos apenas \(m_{\text{try}}\) das \(p\) variáveis;
procuramos o melhor split somente entre essas candidatas;
repetimos até construir muitas árvores.

\[ \boxed{ \text{RF} = \text{Bagging} + \text{subamostragem de variáveis em cada split} } \]

Onde Bagging e Random Forest se separam?

No Bagging, todas as \(p\) variáveis podem disputar cada split.

No Random Forest, apenas \(m_{\text{try}}<p\) variáveis sorteadas podem disputar aquele split.

Importante

O subconjunto de variáveis é sorteado novamente em cada nó. Essa aleatoriedade adicional ajuda a reduzir a correlação entre as árvores.

Bagging versus Random Forest

	Bagging	Random Forest
Bootstrap de observações	sim	sim
Variáveis candidatas por split	todas	subconjunto aleatório
Objetivo adicional	estabilizar	estabilizar + descorrelacionar
Regressão	média	média
Classificação	voto/probabilidades	voto/probabilidades

Bagging versus Random Forest

\[ m_{\text{try}}=p, \]

o Random Forest se reduz, essencialmente, ao Bagging de árvores.

Com apenas uma variável preditora, não é possível visualizar a diferença essencial entre Bagging e Random Forest: não há variáveis para sortear. Por isso, uma animação univariada de RF se comporta como Bagging.

O que \(m_{\text{try}}\) controla?

\[ m_{\text{try}} = \text{número de variáveis candidatas em cada nó}. \]

valor grande \(\rightarrow\) árvores mais parecidas
valor pequeno \(\rightarrow\) árvores mais diversas
pequeno demais \(\rightarrow\) splits individuais podem piorar

Portanto, existe um compromisso:

\[ \boxed{ \text{força de cada árvore} \quad\text{versus}\quad \text{correlação entre árvores} } \]

\(m_{\text{try}}\) deve ser tratado como hiperparâmetro e pode ser ajustado por validação.

OOB: validação “embutida” no bootstrap

Para cada árvore \(T_b\), a amostra bootstrap deixa algumas observações de fora.

Elas são chamadas de out-of-bag (OOB):

\[ \boxed{ OOB_b = \{\text{observações não utilizadas no treinamento de }T_b\} } \]

Em média, aproximadamente 36,8% das observações ficam OOB para cada árvore.

OOB: validação “embutida” no bootstrap

Para avaliar uma observação \(i\):

selecione apenas as árvores para as quais \(i\) ficou OOB;
obtenha as previsões dessas árvores para \(\mathbf{x}_i\);
agregue essas previsões, obtendo \(\hat y_i^{OOB}\);
compare \(\hat y_i^{OOB}\) com o valor observado \(y_i\), usando, por exemplo,

\[ RMSE_{OOB} = \sqrt{ \frac{1}{n} \sum_{i=1}^{n} \left(y_i-\hat{y}_i^{OOB}\right)^2 } \]

OOB: validação “embutida” no bootstrap

Regressão

Agregamos pela média:

\[ \hat y_i^{OOB} = \frac{1}{|\mathcal B_i|} \sum_{b\in\mathcal B_i} T_b(\mathbf{x}_i) \]

Classificação

Agregamos por votação ou pelas probabilidades estimadas:

\[ \hat y_i^{OOB} = \operatorname{classe} \left( \{T_b(\mathbf{x}_i):b\in\mathcal B_i\} \right) \]

Ideia central: cada observação é avaliada somente pelas árvores que não a utilizaram no treinamento.

\(\Rightarrow\) O próprio bootstrap fornece uma estimativa interna do desempenho preditivo.

Boosting

Construir o modelo sequencialmente, fazendo cada nova árvore corrigir o modelo atual

Boosting: árvores que aprendem sequencialmente

Bagging e Random Forest constroem árvores aproximadamente em paralelo.

No boosting, cada nova árvore depende do modelo que já foi construído:

\[ \hat h_1 \;\longrightarrow\; \hat h_2 \;\longrightarrow\; \hat h_3 \;\longrightarrow\;\cdots \]

A ideia é simples:

Cada nova árvore tenta aprender uma correção para os erros que ainda permanecem no modelo.

Assim, em vez de combinar árvores independentes,

\[ \boxed{ \text{modelo atual} \;\longrightarrow\; \text{erro atual} \;\longrightarrow\; \text{nova árvore} \;\longrightarrow\; \text{modelo melhorado} } \]

Boosting: modelo atual + uma correção

Na iteração \(b\), já temos um modelo acumulado:

\[ \hat g^{(b-1)}(\mathbf{x}) \]

A nova árvore \(\hat h_b(\mathbf{x})\) não precisa resolver todo o problema.

Ela aprende apenas uma correção.

O modelo é atualizado por

\[ \boxed{ \hat g^{(b)}(\mathbf{x}) = \hat g^{(b-1)}(\mathbf{x}) + \lambda \hat h_b(\mathbf{x}) } \]

Boosting: modelo atual + uma correção

em que:

\(\hat g^{(b-1)}(\mathbf{x})\): modelo atual;
\(\hat h_b(\mathbf{x})\): correção aprendida pela nova árvore;
\(\lambda\): learning rate.

Ideia central: boosting constrói uma função complexa acumulando muitas correções simples.

Boosting em regressão: quanto ainda falta corrigir?

Considere a observação \(i\).

O modelo atual prevê

\[ \hat g^{(b-1)}(\mathbf{x}_i), \]

mas observamos \(y_i\).

Boosting em regressão: quanto ainda falta corrigir?

A diferença é

\[ \small \boxed{ r_i^{(b)} = y_i-\hat g^{(b-1)}(\mathbf{x}_i) } \]

\(r_i^{(b)}>0\)

O modelo previu abaixo do observado

\[ \small y_i > \hat g^{(b-1)}(\mathbf{x}_i) \]

A previsão precisa aumentar.

\(r_i^{(b)}<0\)

O modelo previu acima do observado

\[ \small y_i < \hat g^{(b-1)}(\mathbf{x}_i) \]

A previsão precisa diminuir.

O resíduo informa simultaneamente a direção e o tamanho da correção necessária.

A nova árvore aprende o que ainda falta

Na iteração \(b\), usamos os resíduos como nova resposta:

\[ (\mathbf{x}_i,r_i^{(b)}), \qquad i=1,\ldots,n \]

A nova árvore é ajustada para aproximar

\[ \boxed{ \hat h_b(\mathbf{x}_i) \approx r_i^{(b)} } \]

Portanto,

\[ \mathbf{x}_i \longrightarrow r_i^{(b)} \longrightarrow \hat h_b(\mathbf{x}_i) \]

A nova árvore aprende o que ainda falta

Depois incorporamos uma fração dessa correção:

\[ \boxed{ \hat g^{(b)}(\mathbf{x}) = \hat g^{(b-1)}(\mathbf{x}) + \lambda\hat h_b(\mathbf{x}) } \]

A nova árvore não prevê diretamente \(Y\): ela aprende como corrigir o modelo atual.

Uma iteração do boosting

Na iteração \(b\):

\[ \boxed{ \begin{array}{c} \text{1. Modelo atual}\\[2mm] \hat g^{(b-1)}(\mathbf{x}) \end{array} } \quad\longrightarrow\quad \boxed{ \begin{array}{c} \text{2. Calcular resíduos}\\[2mm] r_i^{(b)} = y_i-\hat g^{(b-1)}(\mathbf{x}_i) \end{array} } \]

\[ \Downarrow \]

\[ \boxed{ \begin{array}{c} \text{3. Aprender a correção}\\[2mm] \hat h_b(\mathbf{x}) \end{array} } \quad\longrightarrow\quad \boxed{ \begin{array}{c} \text{4. Atualizar}\\[2mm] \hat g^{(b)} = \hat g^{(b-1)} + \lambda\hat h_b \end{array} } \]

Depois da atualização, calculamos novos erros e repetimos o processo.

Boosting: construção sequencial do modelo

modelo atual \(\rightarrow\) erros restantes \(\rightarrow\) nova árvore \(\rightarrow\) pequena correção \(\rightarrow\) novo modelo

Boosting em regressão: veja o modelo aprender

A nova árvore não representa a previsão final.

Ela representa apenas a correção \(\hat h_b(\mathbf{x})\).

A previsão é dada pelo modelo acumulado \(\hat g^{(b)}(\mathbf{x})\).

Por que os resíduos aparecem?

Até agora usamos o resíduo

\[ r_i^{(b)} = y_i-\hat g^{(b-1)}(\mathbf{x}_i) \]

Mas isso não é uma escolha arbitrária.

Considere a perda quadrática:

\[ L(y,g)=(y-g)^2 \]

Por que os resíduos aparecem?

O gradiente da perda em relação à previsão \(g\) é

\[ \boxed{ \nabla_g L(y,g) = \frac{\partial L(y,g)}{\partial g} = -2(y-g) } \]

Aqui, como derivamos em relação a uma única quantidade \(g\), o gradiente é simplesmente a derivada da perda em relação à previsão.

O gradiente indica a direção de aumento da perda.

Por que os resíduos aparecem?

Logo, a direção oposta ao gradiente é

\[ -\frac{\partial L(y,g)}{\partial g} = 2(y-g) \]

Portanto,

\[ \boxed{ -\frac{\partial L}{\partial g} \propto y-g = r } \]

Com perda quadrática, seguir o gradiente negativo equivale a aprender os resíduos.

Gradient Boosting: a ideia mais geral

Agora podemos generalizar.

Para uma função de perda \(L(y,g)\), definimos o pseudo-resíduo:

\[ \boxed{ r_i^{(b)} = - \left. \frac{\partial L(y_i,g)} {\partial g} \right|_{ g=\hat g^{(b-1)}(\mathbf{x}_i) } } \]

A nova árvore \(\hat h_b\) tenta aprender esses pseudo-resíduos.

Depois,

\[ \hat g^{(b)}(\mathbf{x}) = \hat g^{(b-1)}(\mathbf{x}) + \lambda\hat h_b(\mathbf{x}) \]

Gradient Boosting: a ideia mais geral

Assim,

\[ \boxed{ \text{Gradient Boosting} = \text{corrigir o modelo na direção que reduz a perda} } \]

O resíduo usual é apenas um caso particular do pseudo-resíduo.

Regressão e classificação: o que muda?

A estrutura do algoritmo permanece a mesma:

\[ \boxed{ \text{modelo atual} \rightarrow \text{perda} \rightarrow \text{pseudo-resíduos} \rightarrow \text{nova árvore} \rightarrow \text{atualização} } \]

O que muda é principalmente a função de perda.

	Regressão	Classificação binária
Resposta	\(y\in\mathbb R\)	\(y\in\{0,1\}\)
Exemplo de perda	quadrática	log-loss
Correção	relacionada a \(y-\hat g\)	relacionada a \(y-\hat p\)
Saída final	valor contínuo	probabilidade/classe

Regressão e classificação: o que muda?

Boosting não é essencialmente um algoritmo de regressão ou classificação.

Ele é uma estratégia para reduzir iterativamente uma função de perda.

E na classificação?

Para \(Y\in\{0,1\}\), não calculamos um resíduo entre a classe observada e uma classe predita como se fossem valores contínuos.

Em vez disso, trabalhamos com uma perda apropriada para classificação.

Para classificação binária, uma escolha comum é a log-loss:

\[ \boxed{ L(y,p) = -\left[ y\log(p) + (1-y)\log(1-p) \right] } \]

em que

\[ p=P(Y=1\mid\mathbf{x}) \]

E na classificação?

O princípio continua sendo o mesmo:

\[ \boxed{ \text{encontrar a direção que reduz a perda} } \]

Classificação binária: score e probabilidade

No Gradient Boosting binário, é útil distinguir o score acumulado

\[ F^{(b)}(\mathbf{x}) \]

da probabilidade estimada.

A probabilidade é obtida pela função logística:

\[ \boxed{ \hat p^{(b)}(\mathbf{x}) = \frac{1} {1+\exp[-F^{(b)}(\mathbf{x})]} } \]

Classificação binária: score e probabilidade

As árvores são acumuladas na escala do score:

\[ \boxed{ F^{(b)}(\mathbf{x}) = F^{(b-1)}(\mathbf{x}) + \lambda\hat h_b(\mathbf{x}) } \]

e o score é então convertido em probabilidade.

A soma das árvores não precisa estar limitada entre \(0\) e \(1\).

É a transformação logística que produz uma probabilidade.

Classificação binária: o que a nova árvore aprende?

Com log-loss e

\[ \hat p_i^{(b-1)} = P(Y_i=1\mid\mathbf{x}_i), \]

o gradiente negativo leva ao pseudo-resíduo

\[ \boxed{ r_i^{(b)} = y_i-\hat p_i^{(b-1)} } \]

Classificação binária: o que a nova árvore aprende?

Por exemplo:

\(y_i\)	\(\hat p_i^{(b-1)}\)	\(r_i^{(b)}\)	Interpretação
1	0,95	0,05	quase nada a corrigir
1	0,20	0,80	aumentar evidência para classe 1
0	0,10	-0,10	pequena correção
0	0,85	-0,85	reduzir evidência para classe 1

Quanto mais confiante e errada estiver a previsão atual, maior será a magnitude da correção.

Boosting em classificação: veja a correção acontecer

Regressão e classificação: a mesma lógica

Regressão

Perda quadrática:

\[ L(y,g)=(y-g)^2 \]

Pseudo-resíduo:

\[ r_i^{(b)} \propto y_i-\hat g^{(b-1)}(\mathbf{x}_i) \]

Corrigir o valor previsto.

Classificação

Log-loss:

\[ L(y,p) = -[y\log p+(1-y)\log(1-p)] \]

Pseudo-resíduo:

\[ r_i^{(b)} = y_i-\hat p_i^{(b-1)} \]

Corrigir a evidência/probabilidade.

Regressão e classificação: a mesma lógica

O que permanece:

modelo atual + pequena correção

O que muda:

a perda e, consequentemente, o pseudo-resíduo.

O papel do learning rate \(\lambda\)

Cada árvore sugere uma correção \(\hat h_b(\mathbf{x})\).

O learning rate determina quanto dessa correção será incorporado:

\[ \boxed{ \hat g^{(b)}(\mathbf{x}) = \hat g^{(b-1)}(\mathbf{x}) + \lambda\hat h_b(\mathbf{x}) } \]

O papel do learning rate \(\lambda\)

\(\lambda\) pequeno

correções menores;
aprendizado mais gradual;
normalmente exige mais árvores;
maior controle sobre o processo.

\(\lambda\) grande

correções maiores;
aprendizado mais rápido;
pode exigir menos árvores;
pode sobreajustar mais cedo.

\(\lambda\) controla o tamanho do passo, não a direção da correção.

\(\lambda\) e \(B\) trabalham juntos

Na figura, todos os modelos possuem o mesmo número de árvores:

\[ B=100 \]

Quando \(\lambda\) aumenta, cada árvore exerce maior influência sobre o modelo acumulado.

Não faz sentido escolher \(\lambda\) isoladamente.

\[ \boxed{ \lambda\;\text{e}\;B \quad\text{devem ser analisados conjuntamente} } \]

Por que usar árvores simples?

Cada árvore do boosting precisa aprender apenas uma parte da correção.

Por isso, normalmente utilizamos árvores relativamente rasas como modelos base.

Uma árvore simples:

captura uma estrutura que ainda falta ao modelo;
evita correções excessivamente complexas em uma única etapa;
permite que o padrão seja construído gradualmente.

Por que usar árvores simples?

Um caso extremo é o stump:

\[ \boxed{\text{stump}=\text{árvore com apenas um split}} \]

Um modelo base não precisa ser excelente sozinho.

Ele precisa fornecer uma correção útil quando combinado com as demais árvores.

Profundidade da árvore: complexidade da correção

Árvores rasas

Correções mais simples e graduais.

\[ \text{menor complexidade por etapa} \]

Árvores profundas

Cada árvore consegue aprender correções muito mais complexas.

\[ \text{maior risco de aprender ruído} \]

A complexidade do boosting depende conjuntamente de:

\[ \boxed{ \lambda,\qquad B,\qquad \text{complexidade das árvores} } \]

Boosting: a ideia que deve ficar

Boosting constrói o modelo sequencialmente:

\[ \small \boxed{ \text{modelo atual} \rightarrow \text{avaliar a perda} \rightarrow \text{aprender uma correção} \rightarrow \text{atualizar} \rightarrow \text{repetir} } \]

No Gradient Boosting, a correção é guiada por

\[ \boxed{ r_i^{(b)} = - \left. \frac{\partial L(y_i,g)} {\partial g} \right|_{g=\hat g^{(b-1)}(\mathbf{x}_i)} } \]

Boosting: a ideia que deve ficar

perda quadrática \(\Rightarrow\) resíduos;
log-loss \(\Rightarrow\) pseudo-resíduos de classificação;
\(\lambda\) controla o tamanho de cada passo;
\(B\) controla quantas correções são acumuladas;
a profundidade controla a complexidade de cada correção.

Bagging/RF: construir várias árvores e depois agregá-las.

Boosting: construir cada nova árvore para melhorar o que já foi aprendido.

Três ensembles, três mecanismos

Bagging, Random Forest e Boosting

	Bagging	Random Forest	Boosting
Construção	paralela	paralela	sequencial
Reamostragem	bootstrap	bootstrap	depende do algoritmo
Variáveis por split	todas	subconjunto	geralmente todas
Principal ideia	média reduz variância	reduzir variância e correlação	corrigir erros/gradiente
Árvores	usualmente profundas	usualmente profundas	usualmente rasas
Regressão	média	média	soma aditiva
Classificação	voto/prob.	voto/prob.	escore/prob. aditivos

O que permanece igual entre regressão e classificação?

A estrutura geral:

\[ \boxed{ \text{regras recursivas} \rightarrow \text{regiões} \rightarrow \text{folhas} } \]

e as ideias dos ensembles:

Bagging: agregar
Random Forest: agregar árvores menos correlacionadas
Boosting: somar correções sequenciais

O que muda entre regressão e classificação?

Componente	Regressão	Classificação
alvo	número	classe
split de árvore	RSS/variância	Gini/entropia
folha	média	probabilidade/classe
perda típica	quadrática	log-loss, erro etc.
bagging/RF	média	probabilidade média/voto
boosting	resíduos sob MSE	pseudo-resíduos da perda

A mudança não está na ideia de “árvore”. Está na função de perda, no critério de split e na forma de produzir/agregar a previsão.

Como escolher na prática?

Uma leitura estatística

Árvore individual

máxima interpretabilidade
regras explícitas
maior instabilidade

Bagging

reduz variância
perde parte da interpretabilidade da árvore única

Uma leitura estatística

Random Forest

reduz variância e correlação entre árvores
forte baseline para dados tabulares

Boosting

constrói modelo aditivo de forma sequencial
frequentemente alto desempenho
maior sensibilidade à escolha dos hiperparâmetros

Fluxo de modelagem

\[ \small \boxed{ \text{treino} \rightarrow \text{reamostragem/validação} \rightarrow \text{ajuste de hiperparâmetros} \rightarrow \text{modelo final} \rightarrow \text{teste} } \]

Exemplos de hiperparâmetros:

árvore: profundidade, tamanho mínimo do nó, poda
Random Forest: \(m_{\text{try}}\), tamanho mínimo do nó, número de árvores
Boosting: \(B\), \(\lambda\), profundidade

O conjunto de teste permanece reservado para a avaliação final.